/**********************
   Velocity UI Pack
**********************/
/* VelocityJS.org UI Pack (5.0.4). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License. Portions copyright Daniel Eden, Christian Pucci. */
;
(function (factory) {
  /* CommonJS module. */
  if (typeof require === "function" && typeof exports === "object") {
    module.exports = factory();
    /* AMD module. */
  } else if (typeof define === "function" && define.amd) {
    define(["velocity"], factory);
    /* Browser globals. */
  } else {
    factory();
  }
}(function () {
  return function (global, window, document, undefined) {
    /*************
        Checks
    *************/
    if (!global.Velocity || !global.Velocity.Utilities) {
      window.console && console.log(
        "Velocity UI Pack: Velocity must be loaded first. Aborting.");
      return;
    } else {
      var Velocity = global.Velocity,
        $ = Velocity.Utilities;
    }
    var velocityVersion = Velocity.version,
      requiredVersion = {
        major: 1,
        minor: 1,
        patch: 0
      };

    function greaterSemver(primary, secondary) {
      var versionInts = [];
      if (!primary || !secondary) {
        return false;
      }
      $.each([primary, secondary], function (i, versionObject) {
        var versionIntsComponents = [];
        $.each(versionObject, function (component, value) {
          while (value.toString().length < 5) {
            value = "0" + value;
          }
          versionIntsComponents.push(value);
        });
        versionInts.push(versionIntsComponents.join(""))
      });
      return (parseFloat(versionInts[0]) > parseFloat(versionInts[1]));
    }
    if (greaterSemver(requiredVersion, velocityVersion)) {
      var abortError =
        "Velocity UI Pack: You need to update Velocity (jquery.velocity.js) to a newer version. Visit http://github.com/julianshapiro/velocity.";
      alert(abortError);
      throw new Error(abortError);
    }
    /************************
       Effect Registration
    ************************/
    /* Note: RegisterUI is a legacy name. */
    Velocity.RegisterEffect = Velocity.RegisterUI = function (effectName,
      properties) {
      /* Animate the expansion/contraction of the elements' parent's height for In/Out effects. */
      function animateParentHeight(elements, direction, totalDuration,
        stagger) {
        var totalHeightDelta = 0,
          parentNode;
        /* Sum the total height (including padding and margin) of all targeted elements. */
        $.each(elements.nodeType ? [elements] : elements, function (i,
          element) {
          if (stagger) {
            /* Increase the totalDuration by the successive delay amounts produced by the stagger option. */
            totalDuration += i * stagger;
          }
          parentNode = element.parentNode;
          $.each(["height", "paddingTop", "paddingBottom",
            "marginTop", "marginBottom"], function (i,
          property) {
            totalHeightDelta += parseFloat(Velocity.CSS
              .getPropertyValue(element, property));
          });
        });
        /* Animate the parent element's height adjustment (with a varying duration multiplier for aesthetic benefits). */
        Velocity.animate(
          parentNode, {
            height: (direction === "In" ? "+" : "-") + "=" +
              totalHeightDelta
          }, {
            queue: false,
            easing: "ease-in-out",
            duration: totalDuration * (direction === "In" ? 0.6 : 1)
          }
        );
      }
      /* Register a custom redirect for each effect. */
      Velocity.Redirects[effectName] = function (element,
        redirectOptions, elementsIndex, elementsSize, elements,
        promiseData) {
        var finalElement = (elementsIndex === elementsSize - 1);
        if (typeof properties.defaultDuration === "function") {
          properties.defaultDuration = properties.defaultDuration
            .call(elements, elements);
        } else {
          properties.defaultDuration = parseFloat(properties
            .defaultDuration);
        }
        /* Iterate through each effect's call array. */
        for (var callIndex = 0; callIndex < properties.calls
          .length; callIndex++) {
          var call = properties.calls[callIndex],
            propertyMap = call[0],
            redirectDuration = (redirectOptions.duration || properties
              .defaultDuration || 1000),
            durationPercentage = call[1],
            callOptions = call[2] || {},
            opts = {};
          /* Assign the whitelisted per-call options. */
          opts.duration = redirectDuration * (durationPercentage ||
          1);
          opts.queue = redirectOptions.queue || "";
          opts.easing = callOptions.easing || "ease";
          opts.delay = parseFloat(callOptions.delay) || 0;
          opts._cacheValues = callOptions._cacheValues || true;
          /* Special processing for the first effect call. */
          if (callIndex === 0) {
            /* If a delay was passed into the redirect, combine it with the first call's delay. */
            opts.delay += (parseFloat(redirectOptions.delay) || 0);
            if (elementsIndex === 0) {
              opts.begin = function () {
                /* Only trigger a begin callback on the first effect call with the first element in the set. */
                redirectOptions.begin && redirectOptions.begin.call(
                  elements, elements);
                var direction = effectName.match(/(In|Out)$/);
                /* Make "in" transitioning elements invisible immediately so that there's no FOUC between now
                   and the first RAF tick. */
                if ((direction && direction[0] === "In") &&
                  propertyMap.opacity !== undefined) {
                  $.each(elements.nodeType ? [elements] : elements,
                    function (i, element) {
                      Velocity.CSS.setPropertyValue(element,
                        "opacity", 0);
                    });
                }
                /* Only trigger animateParentHeight() if we're using an In/Out transition. */
                if (redirectOptions.animateParentHeight &&
                  direction) {
                  animateParentHeight(elements, direction[0],
                    redirectDuration + opts.delay, redirectOptions
                    .stagger);
                }
              }
            }
            /* If the user isn't overriding the display option, default to "auto" for "In"-suffixed transitions. */
            if (redirectOptions.display !== null) {
              if (redirectOptions.display !== undefined &&
                redirectOptions.display !== "none") {
                opts.display = redirectOptions.display;
              } else if (/In$/.test(effectName)) {
                /* Inline elements cannot be subjected to transforms, so we switch them to inline-block. */
                var defaultDisplay = Velocity.CSS.Values
                  .getDisplayType(element);
                opts.display = (defaultDisplay === "inline") ?
                  "inline-block" : defaultDisplay;
              }
            }
            if (redirectOptions.visibility && redirectOptions
              .visibility !== "hidden") {
              opts.visibility = redirectOptions.visibility;
            }
          }
          /* Special processing for the last effect call. */
          if (callIndex === properties.calls.length - 1) {
            /* Append promise resolving onto the user's redirect callback. */
            function injectFinalCallbacks() {
              if ((redirectOptions.display === undefined ||
                  redirectOptions.display === "none") && /Out$/.test(
                  effectName)) {
                $.each(elements.nodeType ? [elements] : elements,
                  function (i, element) {
                    Velocity.CSS.setPropertyValue(element,
                      "display", "none");
                  });
              }
              redirectOptions.complete && redirectOptions.complete
                .call(elements, elements);
              if (promiseData) {
                promiseData.resolver(elements || element);
              }
            }
            opts.complete = function () {
              if (properties.reset) {
                for (var resetProperty in properties.reset) {
                  var resetValue = properties.reset[resetProperty];
                  /* Format each non-array value in the reset property map to [ value, value ] so that changes apply
                     immediately and DOM querying is avoided (via forcefeeding). */
                  /* Note: Don't forcefeed hooks, otherwise their hook roots will be defaulted to their null values. */
                  if (Velocity.CSS.Hooks.registered[
                    resetProperty] === undefined && (
                      typeof resetValue === "string" ||
                      typeof resetValue === "number")) {
                    properties.reset[resetProperty] = [properties
                      .reset[resetProperty], properties.reset[
                        resetProperty]];
                  }
                }
                /* So that the reset values are applied instantly upon the next rAF tick, use a zero duration and parallel queueing. */
                var resetOptions = {
                  duration: 0,
                  queue: false
                };
                /* Since the reset option uses up the complete callback, we trigger the user's complete callback at the end of ours. */
                if (finalElement) {
                  resetOptions.complete = injectFinalCallbacks;
                }
                Velocity.animate(element, properties.reset,
                  resetOptions);
                /* Only trigger the user's complete callback on the last effect call with the last element in the set. */
              } else if (finalElement) {
                injectFinalCallbacks();
              }
            };
            if (redirectOptions.visibility === "hidden") {
              opts.visibility = redirectOptions.visibility;
            }
          }
          Velocity.animate(element, propertyMap, opts);
        }
      };
      /* Return the Velocity object so that RegisterUI calls can be chained. */
      return Velocity;
    };
    /*********************
       Packaged Effects
    *********************/
    /* Externalize the packagedEffects data so that they can optionally be modified and re-registered. */
    /* Support: <=IE8: Callouts will have no effect, and transitions will simply fade in/out. IE9/Android 2.3: Most effects are fully supported, the rest fade in/out. All other browsers: full support. */
    Velocity.RegisterEffect.packagedEffects = {
      /* Animate.css */
      "callout.bounce": {
        defaultDuration: 550,
        calls: [
                    [{
            translateY: -30
          }, 0.25],
                    [{
            translateY: 0
          }, 0.125],
                    [{
            translateY: -15
          }, 0.125],
                    [{
            translateY: 0
          }, 0.25]
                ]
      },
      /* Animate.css */
      "callout.shake": {
        defaultDuration: 800,
        calls: [
                    [{
            translateX: -11
          }, 0.125],
                    [{
            translateX: 11
          }, 0.125],
                    [{
            translateX: -11
          }, 0.125],
                    [{
            translateX: 11
          }, 0.125],
                    [{
            translateX: -11
          }, 0.125],
                    [{
            translateX: 11
          }, 0.125],
                    [{
            translateX: -11
          }, 0.125],
                    [{
            translateX: 0
          }, 0.125]
                ]
      },
      /* Animate.css */
      "callout.flash": {
        defaultDuration: 1100,
        calls: [
                    [{
            opacity: [0, "easeInOutQuad", 1]
          }, 0.25],
                    [{
            opacity: [1, "easeInOutQuad"]
          }, 0.25],
                    [{
            opacity: [0, "easeInOutQuad"]
          }, 0.25],
                    [{
            opacity: [1, "easeInOutQuad"]
          }, 0.25]
                ]
      },
      /* Animate.css */
      "callout.pulse": {
        defaultDuration: 825,
        calls: [
                    [{
            scaleX: 1.1,
            scaleY: 1.1
          }, 0.50, {
            easing: "easeInExpo"
          }],
                    [{
            scaleX: 1,
            scaleY: 1
          }, 0.50]
                ]
      },
      /* Animate.css */
      "callout.swing": {
        defaultDuration: 950,
        calls: [
                    [{
            rotateZ: 15
          }, 0.20],
                    [{
            rotateZ: -10
          }, 0.20],
                    [{
            rotateZ: 5
          }, 0.20],
                    [{
            rotateZ: -5
          }, 0.20],
                    [{
            rotateZ: 0
          }, 0.20]
                ]
      },
      /* Animate.css */
      "callout.tada": {
        defaultDuration: 1000,
        calls: [
                    [{
            scaleX: 0.9,
            scaleY: 0.9,
            rotateZ: -3
          }, 0.10],
                    [{
            scaleX: 1.1,
            scaleY: 1.1,
            rotateZ: 3
          }, 0.10],
                    [{
            scaleX: 1.1,
            scaleY: 1.1,
            rotateZ: -3
          }, 0.10],
                    ["reverse", 0.125],
                    ["reverse", 0.125],
                    ["reverse", 0.125],
                    ["reverse", 0.125],
                    ["reverse", 0.125],
                    [{
            scaleX: 1,
            scaleY: 1,
            rotateZ: 0
          }, 0.20]
                ]
      },
      "transition.fadeIn": {
        defaultDuration: 500,
        calls: [
                    [{
            opacity: [1, 0]
          }]
                ]
      },
      "transition.fadeOut": {
        defaultDuration: 500,
        calls: [
                    [{
            opacity: [0, 1]
          }]
                ]
      },
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipXIn": {
        defaultDuration: 700,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [800, 800],
            rotateY: [0, -55]
          }]
                ],
        reset: {
          transformPerspective: 0
        }
      },
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipXOut": {
        defaultDuration: 700,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [800, 800],
            rotateY: 55
          }]
                ],
        reset: {
          transformPerspective: 0,
          rotateY: 0
        }
      },
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipYIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [800, 800],
            rotateX: [0, -45]
          }]
                ],
        reset: {
          transformPerspective: 0
        }
      },
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipYOut": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [800, 800],
            rotateX: 25
          }]
                ],
        reset: {
          transformPerspective: 0,
          rotateX: 0
        }
      },
      /* Animate.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipBounceXIn": {
        defaultDuration: 900,
        calls: [
                    [{
            opacity: [0.725, 0],
            transformPerspective: [400, 400],
            rotateY: [-10, 90]
          }, 0.50],
                    [{
            opacity: 0.80,
            rotateY: 10
          }, 0.25],
                    [{
            opacity: 1,
            rotateY: 0
          }, 0.25]
                ],
        reset: {
          transformPerspective: 0
        }
      },
      /* Animate.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipBounceXOut": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [0.9, 1],
            transformPerspective: [400, 400],
            rotateY: -10
          }, 0.50],
                    [{
            opacity: 0,
            rotateY: 90
          }, 0.50]
                ],
        reset: {
          transformPerspective: 0,
          rotateY: 0
        }
      },
      /* Animate.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipBounceYIn": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [0.725, 0],
            transformPerspective: [400, 400],
            rotateX: [-10, 90]
          }, 0.50],
                    [{
            opacity: 0.80,
            rotateX: 10
          }, 0.25],
                    [{
            opacity: 1,
            rotateX: 0
          }, 0.25]
                ],
        reset: {
          transformPerspective: 0
        }
      },
      /* Animate.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.flipBounceYOut": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [0.9, 1],
            transformPerspective: [400, 400],
            rotateX: -15
          }, 0.50],
                    [{
            opacity: 0,
            rotateX: 90
          }, 0.50]
                ],
        reset: {
          transformPerspective: 0,
          rotateX: 0
        }
      },
      /* Magic.css */
      "transition.swoopIn": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [1, 0],
            transformOriginX: ["100%", "50%"],
            transformOriginY: ["100%", "100%"],
            scaleX: [1, 0],
            scaleY: [1, 0],
            translateX: [0, -700],
            translateZ: 0
          }]
                ],
        reset: {
          transformOriginX: "50%",
          transformOriginY: "50%"
        }
      },
      /* Magic.css */
      "transition.swoopOut": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [0, 1],
            transformOriginX: ["50%", "100%"],
            transformOriginY: ["100%", "100%"],
            scaleX: 0,
            scaleY: 0,
            translateX: -700,
            translateZ: 0
          }]
                ],
        reset: {
          transformOriginX: "50%",
          transformOriginY: "50%",
          scaleX: 1,
          scaleY: 1,
          translateX: 0
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3. (Fades and scales only.) */
      "transition.whirlIn": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [1, 0],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: [1, 0],
            scaleY: [1, 0],
            rotateY: [0, 160]
          }, 1, {
            easing: "easeInOutSine"
          }]
                ]
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3. (Fades and scales only.) */
      "transition.whirlOut": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [0, "easeInOutQuint", 1],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: 0,
            scaleY: 0,
            rotateY: 160
          }, 1, {
            easing: "swing"
          }]
                ],
        reset: {
          scaleX: 1,
          scaleY: 1,
          rotateY: 0
        }
      },
      "transition.shrinkIn": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [1, 0],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: [1, 1.5],
            scaleY: [1, 1.5],
            translateZ: 0
          }]
                ]
      },
      "transition.shrinkOut": {
        defaultDuration: 600,
        calls: [
                    [{
            opacity: [0, 1],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: 1.3,
            scaleY: 1.3,
            translateZ: 0
          }]
                ],
        reset: {
          scaleX: 1,
          scaleY: 1
        }
      },
      "transition.expandIn": {
        defaultDuration: 700,
        calls: [
                    [{
            opacity: [1, 0],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: [1, 0.625],
            scaleY: [1, 0.625],
            translateZ: 0
          }]
                ]
      },
      "transition.expandOut": {
        defaultDuration: 700,
        calls: [
                    [{
            opacity: [0, 1],
            transformOriginX: ["50%", "50%"],
            transformOriginY: ["50%", "50%"],
            scaleX: 0.5,
            scaleY: 0.5,
            translateZ: 0
          }]
                ],
        reset: {
          scaleX: 1,
          scaleY: 1
        }
      },
      /* Animate.css */
      "transition.bounceIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            scaleX: [1.05, 0.3],
            scaleY: [1.05, 0.3]
          }, 0.40],
                    [{
            scaleX: 0.9,
            scaleY: 0.9,
            translateZ: 0
          }, 0.20],
                    [{
            scaleX: 1,
            scaleY: 1
          }, 0.50]
                ]
      },
      /* Animate.css */
      "transition.bounceOut": {
        defaultDuration: 800,
        calls: [
                    [{
            scaleX: 0.95,
            scaleY: 0.95
          }, 0.35],
                    [{
            scaleX: 1.1,
            scaleY: 1.1,
            translateZ: 0
          }, 0.35],
                    [{
            opacity: [0, 1],
            scaleX: 0.3,
            scaleY: 0.3
          }, 0.30]
                ],
        reset: {
          scaleX: 1,
          scaleY: 1
        }
      },
      /* Animate.css */
      "transition.bounceUpIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [-30, 1000]
          }, 0.60, {
            easing: "easeOutCirc"
          }],
                    [{
            translateY: 10
          }, 0.20],
                    [{
            translateY: 0
          }, 0.20]
                ]
      },
      /* Animate.css */
      "transition.bounceUpOut": {
        defaultDuration: 1000,
        calls: [
                    [{
            translateY: 20
          }, 0.20],
                    [{
            opacity: [0, "easeInCirc", 1],
            translateY: -1000
          }, 0.80]
                ],
        reset: {
          translateY: 0
        }
      },
      /* Animate.css */
      "transition.bounceDownIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [30, -1000]
          }, 0.60, {
            easing: "easeOutCirc"
          }],
                    [{
            translateY: -10
          }, 0.20],
                    [{
            translateY: 0
          }, 0.20]
                ]
      },
      /* Animate.css */
      "transition.bounceDownOut": {
        defaultDuration: 1000,
        calls: [
                    [{
            translateY: -20
          }, 0.20],
                    [{
            opacity: [0, "easeInCirc", 1],
            translateY: 1000
          }, 0.80]
                ],
        reset: {
          translateY: 0
        }
      },
      /* Animate.css */
      "transition.bounceLeftIn": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [30, -1250]
          }, 0.60, {
            easing: "easeOutCirc"
          }],
                    [{
            translateX: -10
          }, 0.20],
                    [{
            translateX: 0
          }, 0.20]
                ]
      },
      /* Animate.css */
      "transition.bounceLeftOut": {
        defaultDuration: 750,
        calls: [
                    [{
            translateX: 30
          }, 0.20],
                    [{
            opacity: [0, "easeInCirc", 1],
            translateX: -1250
          }, 0.80]
                ],
        reset: {
          translateX: 0
        }
      },
      /* Animate.css */
      "transition.bounceRightIn": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [-30, 1250]
          }, 0.60, {
            easing: "easeOutCirc"
          }],
                    [{
            translateX: 10
          }, 0.20],
                    [{
            translateX: 0
          }, 0.20]
                ]
      },
      /* Animate.css */
      "transition.bounceRightOut": {
        defaultDuration: 750,
        calls: [
                    [{
            translateX: -30
          }, 0.20],
                    [{
            opacity: [0, "easeInCirc", 1],
            translateX: 1250
          }, 0.80]
                ],
        reset: {
          translateX: 0
        }
      },
      "transition.slideUpIn": {
        defaultDuration: 900,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [0, 20],
            translateZ: 0
          }]
                ]
      },
      "transition.slideUpOut": {
        defaultDuration: 900,
        calls: [
                    [{
            opacity: [0, 1],
            translateY: -20,
            translateZ: 0
          }]
                ],
        reset: {
          translateY: 0
        }
      },
      "transition.slideDownIn": {
        defaultDuration: 900,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [0, -20],
            translateZ: 0
          }]
                ]
      },
      "transition.slideDownOut": {
        defaultDuration: 900,
        calls: [
                    [{
            opacity: [0, 1],
            translateY: 20,
            translateZ: 0
          }]
                ],
        reset: {
          translateY: 0
        }
      },
      "transition.slideLeftIn": {
        defaultDuration: 1000,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [0, -20],
            translateZ: 0
          }]
                ]
      },
      "transition.slideLeftOut": {
        defaultDuration: 1050,
        calls: [
                    [{
            opacity: [0, 1],
            translateX: -20,
            translateZ: 0
          }]
                ],
        reset: {
          translateX: 0
        }
      },
      "transition.slideRightIn": {
        defaultDuration: 1000,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [0, 20],
            translateZ: 0
          }]
                ]
      },
      "transition.slideRightOut": {
        defaultDuration: 1050,
        calls: [
                    [{
            opacity: [0, 1],
            translateX: 20,
            translateZ: 0
          }]
                ],
        reset: {
          translateX: 0
        }
      },
      "transition.slideUpBigIn": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [0, 75],
            translateZ: 0
          }]
                ]
      },
      "transition.slideUpBigOut": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [0, 1],
            translateY: -75,
            translateZ: 0
          }]
                ],
        reset: {
          translateY: 0
        }
      },
      "transition.slideDownBigIn": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [1, 0],
            translateY: [0, -75],
            translateZ: 0
          }]
                ]
      },
      "transition.slideDownBigOut": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [0, 1],
            translateY: 75,
            translateZ: 0
          }]
                ],
        reset: {
          translateY: 0
        }
      },
      "transition.slideLeftBigIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [0, -75],
            translateZ: 0
          }]
                ]
      },
      "transition.slideLeftBigOut": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [0, 1],
            translateX: -75,
            translateZ: 0
          }]
                ],
        reset: {
          translateX: 0
        }
      },
      "transition.slideRightBigIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            translateX: [0, 75],
            translateZ: 0
          }]
                ]
      },
      "transition.slideRightBigOut": {
        defaultDuration: 750,
        calls: [
                    [{
            opacity: [0, 1],
            translateX: 75,
            translateZ: 0
          }]
                ],
        reset: {
          translateX: 0
        }
      },
      /* Magic.css */
      "transition.perspectiveUpIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [800, 800],
            transformOriginX: [0, 0],
            transformOriginY: ["100%", "100%"],
            rotateX: [0, -180]
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%"
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveUpOut": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [800, 800],
            transformOriginX: [0, 0],
            transformOriginY: ["100%", "100%"],
            rotateX: -180
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%",
          rotateX: 0
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveDownIn": {
        defaultDuration: 800,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [800, 800],
            transformOriginX: [0, 0],
            transformOriginY: [0, 0],
            rotateX: [0, 180]
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%"
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveDownOut": {
        defaultDuration: 850,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [800, 800],
            transformOriginX: [0, 0],
            transformOriginY: [0, 0],
            rotateX: 180
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%",
          rotateX: 0
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveLeftIn": {
        defaultDuration: 950,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [2000, 2000],
            transformOriginX: [0, 0],
            transformOriginY: [0, 0],
            rotateY: [0, -180]
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%"
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveLeftOut": {
        defaultDuration: 950,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [2000, 2000],
            transformOriginX: [0, 0],
            transformOriginY: [0, 0],
            rotateY: -180
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%",
          rotateY: 0
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveRightIn": {
        defaultDuration: 950,
        calls: [
                    [{
            opacity: [1, 0],
            transformPerspective: [2000, 2000],
            transformOriginX: ["100%", "100%"],
            transformOriginY: [0, 0],
            rotateY: [0, 180]
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%"
        }
      },
      /* Magic.css */
      /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
      "transition.perspectiveRightOut": {
        defaultDuration: 950,
        calls: [
                    [{
            opacity: [0, 1],
            transformPerspective: [2000, 2000],
            transformOriginX: ["100%", "100%"],
            transformOriginY: [0, 0],
            rotateY: 180
          }]
                ],
        reset: {
          transformPerspective: 0,
          transformOriginX: "50%",
          transformOriginY: "50%",
          rotateY: 0
        }
      }
    };
    /* Register the packaged effects. */
    for (var effectName in Velocity.RegisterEffect.packagedEffects) {
      Velocity.RegisterEffect(effectName, Velocity.RegisterEffect
        .packagedEffects[effectName]);
    }
    /*********************
       Sequence Running
    **********************/
    /* Note: Sequence calls must use Velocity's single-object arguments syntax. */
    Velocity.RunSequence = function (originalSequence) {
      var sequence = $.extend(true, [], originalSequence);
      if (sequence.length > 1) {
        $.each(sequence.reverse(), function (i, currentCall) {
          var nextCall = sequence[i + 1];
          if (nextCall) {
            /* Parallel sequence calls (indicated via sequenceQueue:false) are triggered
               in the previous call's begin callback. Otherwise, chained calls are normally triggered
               in the previous call's complete callback. */
            var currentCallOptions = currentCall.o || currentCall
              .options,
              nextCallOptions = nextCall.o || nextCall.options;
            var timing = (currentCallOptions && currentCallOptions
                .sequenceQueue === false) ? "begin" : "complete",
              callbackOriginal = nextCallOptions && nextCallOptions[
                timing],
              options = {};
            options[timing] = function () {
              var nextCallElements = nextCall.e || nextCall
                .elements;
              var elements = nextCallElements.nodeType ? [
                nextCallElements] : nextCallElements;
              callbackOriginal && callbackOriginal.call(elements,
                elements);
              Velocity(currentCall);
            }
            if (nextCall.o) {
              nextCall.o = $.extend({}, nextCallOptions, options);
            } else {
              nextCall.options = $.extend({}, nextCallOptions,
                options);
            }
          }
        });
        sequence.reverse();
      }
      Velocity(sequence[0]);
    };
  }((window.jQuery || window.Zepto || window), window, document);
}));
